package com.yscz.bs.lib;

import static io.grpc.MethodDescriptor.generateFullMethodName;
import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
import static io.grpc.stub.ClientCalls.asyncUnaryCall;
import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
import static io.grpc.stub.ClientCalls.blockingUnaryCall;
import static io.grpc.stub.ClientCalls.futureUnaryCall;
import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.15.1)",
    comments = "Source: proto/inquestControl.proto")
public final class InquestControlGrpc {

  private InquestControlGrpc() {}

  public static final String SERVICE_NAME = "InquestControl.InquestControl";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor<com.yscz.bs.lib.InquestControlOuterClass.StartRequest,
      com.yscz.bs.lib.InquestControlOuterClass.StartReply> getStartInquestMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "startInquest",
      requestType = com.yscz.bs.lib.InquestControlOuterClass.StartRequest.class,
      responseType = com.yscz.bs.lib.InquestControlOuterClass.StartReply.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.yscz.bs.lib.InquestControlOuterClass.StartRequest,
      com.yscz.bs.lib.InquestControlOuterClass.StartReply> getStartInquestMethod() {
    io.grpc.MethodDescriptor<com.yscz.bs.lib.InquestControlOuterClass.StartRequest, com.yscz.bs.lib.InquestControlOuterClass.StartReply> getStartInquestMethod;
    if ((getStartInquestMethod = InquestControlGrpc.getStartInquestMethod) == null) {
      synchronized (InquestControlGrpc.class) {
        if ((getStartInquestMethod = InquestControlGrpc.getStartInquestMethod) == null) {
          InquestControlGrpc.getStartInquestMethod = getStartInquestMethod = 
              io.grpc.MethodDescriptor.<com.yscz.bs.lib.InquestControlOuterClass.StartRequest, com.yscz.bs.lib.InquestControlOuterClass.StartReply>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "InquestControl.InquestControl", "startInquest"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.yscz.bs.lib.InquestControlOuterClass.StartRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.yscz.bs.lib.InquestControlOuterClass.StartReply.getDefaultInstance()))
                  .setSchemaDescriptor(new InquestControlMethodDescriptorSupplier("startInquest"))
                  .build();
          }
        }
     }
     return getStartInquestMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.yscz.bs.lib.InquestControlOuterClass.TerminateRequest,
      com.yscz.bs.lib.InquestControlOuterClass.TerminateReply> getTerminateInquestMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "terminateInquest",
      requestType = com.yscz.bs.lib.InquestControlOuterClass.TerminateRequest.class,
      responseType = com.yscz.bs.lib.InquestControlOuterClass.TerminateReply.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.yscz.bs.lib.InquestControlOuterClass.TerminateRequest,
      com.yscz.bs.lib.InquestControlOuterClass.TerminateReply> getTerminateInquestMethod() {
    io.grpc.MethodDescriptor<com.yscz.bs.lib.InquestControlOuterClass.TerminateRequest, com.yscz.bs.lib.InquestControlOuterClass.TerminateReply> getTerminateInquestMethod;
    if ((getTerminateInquestMethod = InquestControlGrpc.getTerminateInquestMethod) == null) {
      synchronized (InquestControlGrpc.class) {
        if ((getTerminateInquestMethod = InquestControlGrpc.getTerminateInquestMethod) == null) {
          InquestControlGrpc.getTerminateInquestMethod = getTerminateInquestMethod = 
              io.grpc.MethodDescriptor.<com.yscz.bs.lib.InquestControlOuterClass.TerminateRequest, com.yscz.bs.lib.InquestControlOuterClass.TerminateReply>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "InquestControl.InquestControl", "terminateInquest"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.yscz.bs.lib.InquestControlOuterClass.TerminateRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.yscz.bs.lib.InquestControlOuterClass.TerminateReply.getDefaultInstance()))
                  .setSchemaDescriptor(new InquestControlMethodDescriptorSupplier("terminateInquest"))
                  .build();
          }
        }
     }
     return getTerminateInquestMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.yscz.bs.lib.InquestControlOuterClass.GetResultRequest,
      com.yscz.bs.lib.InquestControlOuterClass.GetResultReply> getGetResultMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "getResult",
      requestType = com.yscz.bs.lib.InquestControlOuterClass.GetResultRequest.class,
      responseType = com.yscz.bs.lib.InquestControlOuterClass.GetResultReply.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.yscz.bs.lib.InquestControlOuterClass.GetResultRequest,
      com.yscz.bs.lib.InquestControlOuterClass.GetResultReply> getGetResultMethod() {
    io.grpc.MethodDescriptor<com.yscz.bs.lib.InquestControlOuterClass.GetResultRequest, com.yscz.bs.lib.InquestControlOuterClass.GetResultReply> getGetResultMethod;
    if ((getGetResultMethod = InquestControlGrpc.getGetResultMethod) == null) {
      synchronized (InquestControlGrpc.class) {
        if ((getGetResultMethod = InquestControlGrpc.getGetResultMethod) == null) {
          InquestControlGrpc.getGetResultMethod = getGetResultMethod = 
              io.grpc.MethodDescriptor.<com.yscz.bs.lib.InquestControlOuterClass.GetResultRequest, com.yscz.bs.lib.InquestControlOuterClass.GetResultReply>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "InquestControl.InquestControl", "getResult"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.yscz.bs.lib.InquestControlOuterClass.GetResultRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.yscz.bs.lib.InquestControlOuterClass.GetResultReply.getDefaultInstance()))
                  .setSchemaDescriptor(new InquestControlMethodDescriptorSupplier("getResult"))
                  .build();
          }
        }
     }
     return getGetResultMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicRequest,
      com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicReply> getGetRealtimePicMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "getRealtimePic",
      requestType = com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicRequest.class,
      responseType = com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicReply.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicRequest,
      com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicReply> getGetRealtimePicMethod() {
    io.grpc.MethodDescriptor<com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicRequest, com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicReply> getGetRealtimePicMethod;
    if ((getGetRealtimePicMethod = InquestControlGrpc.getGetRealtimePicMethod) == null) {
      synchronized (InquestControlGrpc.class) {
        if ((getGetRealtimePicMethod = InquestControlGrpc.getGetRealtimePicMethod) == null) {
          InquestControlGrpc.getGetRealtimePicMethod = getGetRealtimePicMethod = 
              io.grpc.MethodDescriptor.<com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicRequest, com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicReply>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "InquestControl.InquestControl", "getRealtimePic"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicReply.getDefaultInstance()))
                  .setSchemaDescriptor(new InquestControlMethodDescriptorSupplier("getRealtimePic"))
                  .build();
          }
        }
     }
     return getGetRealtimePicMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.yscz.bs.lib.InquestControlOuterClass.ControlParam,
      com.yscz.bs.lib.InquestControlOuterClass.ControlResult> getAlgControlMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "algControl",
      requestType = com.yscz.bs.lib.InquestControlOuterClass.ControlParam.class,
      responseType = com.yscz.bs.lib.InquestControlOuterClass.ControlResult.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.yscz.bs.lib.InquestControlOuterClass.ControlParam,
      com.yscz.bs.lib.InquestControlOuterClass.ControlResult> getAlgControlMethod() {
    io.grpc.MethodDescriptor<com.yscz.bs.lib.InquestControlOuterClass.ControlParam, com.yscz.bs.lib.InquestControlOuterClass.ControlResult> getAlgControlMethod;
    if ((getAlgControlMethod = InquestControlGrpc.getAlgControlMethod) == null) {
      synchronized (InquestControlGrpc.class) {
        if ((getAlgControlMethod = InquestControlGrpc.getAlgControlMethod) == null) {
          InquestControlGrpc.getAlgControlMethod = getAlgControlMethod = 
              io.grpc.MethodDescriptor.<com.yscz.bs.lib.InquestControlOuterClass.ControlParam, com.yscz.bs.lib.InquestControlOuterClass.ControlResult>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "InquestControl.InquestControl", "algControl"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.yscz.bs.lib.InquestControlOuterClass.ControlParam.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.yscz.bs.lib.InquestControlOuterClass.ControlResult.getDefaultInstance()))
                  .setSchemaDescriptor(new InquestControlMethodDescriptorSupplier("algControl"))
                  .build();
          }
        }
     }
     return getAlgControlMethod;
  }

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static InquestControlStub newStub(io.grpc.Channel channel) {
    return new InquestControlStub(channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static InquestControlBlockingStub newBlockingStub(
      io.grpc.Channel channel) {
    return new InquestControlBlockingStub(channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary calls on the service
   */
  public static InquestControlFutureStub newFutureStub(
      io.grpc.Channel channel) {
    return new InquestControlFutureStub(channel);
  }

  /**
   */
  public static abstract class InquestControlImplBase implements io.grpc.BindableService {

    /**
     * <pre>
     * 审讯控制
     * </pre>
     */
    public void startInquest(com.yscz.bs.lib.InquestControlOuterClass.StartRequest request,
        io.grpc.stub.StreamObserver<com.yscz.bs.lib.InquestControlOuterClass.StartReply> responseObserver) {
      asyncUnimplementedUnaryCall(getStartInquestMethod(), responseObserver);
    }

    /**
     * <pre>
     * 结束面审
     * </pre>
     */
    public void terminateInquest(com.yscz.bs.lib.InquestControlOuterClass.TerminateRequest request,
        io.grpc.stub.StreamObserver<com.yscz.bs.lib.InquestControlOuterClass.TerminateReply> responseObserver) {
      asyncUnimplementedUnaryCall(getTerminateInquestMethod(), responseObserver);
    }

    /**
     * <pre>
     * 获取算法结果
     * </pre>
     */
    public void getResult(com.yscz.bs.lib.InquestControlOuterClass.GetResultRequest request,
        io.grpc.stub.StreamObserver<com.yscz.bs.lib.InquestControlOuterClass.GetResultReply> responseObserver) {
      asyncUnimplementedUnaryCall(getGetResultMethod(), responseObserver);
    }

    /**
     * <pre>
     * 获取实时图片
     * </pre>
     */
    public void getRealtimePic(com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicRequest request,
        io.grpc.stub.StreamObserver<com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicReply> responseObserver) {
      asyncUnimplementedUnaryCall(getGetRealtimePicMethod(), responseObserver);
    }

    /**
     * <pre>
     * 算法控制
     * </pre>
     */
    public void algControl(com.yscz.bs.lib.InquestControlOuterClass.ControlParam request,
        io.grpc.stub.StreamObserver<com.yscz.bs.lib.InquestControlOuterClass.ControlResult> responseObserver) {
      asyncUnimplementedUnaryCall(getAlgControlMethod(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getStartInquestMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.yscz.bs.lib.InquestControlOuterClass.StartRequest,
                com.yscz.bs.lib.InquestControlOuterClass.StartReply>(
                  this, METHODID_START_INQUEST)))
          .addMethod(
            getTerminateInquestMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.yscz.bs.lib.InquestControlOuterClass.TerminateRequest,
                com.yscz.bs.lib.InquestControlOuterClass.TerminateReply>(
                  this, METHODID_TERMINATE_INQUEST)))
          .addMethod(
            getGetResultMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.yscz.bs.lib.InquestControlOuterClass.GetResultRequest,
                com.yscz.bs.lib.InquestControlOuterClass.GetResultReply>(
                  this, METHODID_GET_RESULT)))
          .addMethod(
            getGetRealtimePicMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicRequest,
                com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicReply>(
                  this, METHODID_GET_REALTIME_PIC)))
          .addMethod(
            getAlgControlMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.yscz.bs.lib.InquestControlOuterClass.ControlParam,
                com.yscz.bs.lib.InquestControlOuterClass.ControlResult>(
                  this, METHODID_ALG_CONTROL)))
          .build();
    }
  }

  /**
   */
  public static final class InquestControlStub extends io.grpc.stub.AbstractStub<InquestControlStub> {
    private InquestControlStub(io.grpc.Channel channel) {
      super(channel);
    }

    private InquestControlStub(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected InquestControlStub build(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      return new InquestControlStub(channel, callOptions);
    }

    /**
     * <pre>
     * 审讯控制
     * </pre>
     */
    public void startInquest(com.yscz.bs.lib.InquestControlOuterClass.StartRequest request,
        io.grpc.stub.StreamObserver<com.yscz.bs.lib.InquestControlOuterClass.StartReply> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getStartInquestMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 结束面审
     * </pre>
     */
    public void terminateInquest(com.yscz.bs.lib.InquestControlOuterClass.TerminateRequest request,
        io.grpc.stub.StreamObserver<com.yscz.bs.lib.InquestControlOuterClass.TerminateReply> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getTerminateInquestMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 获取算法结果
     * </pre>
     */
    public void getResult(com.yscz.bs.lib.InquestControlOuterClass.GetResultRequest request,
        io.grpc.stub.StreamObserver<com.yscz.bs.lib.InquestControlOuterClass.GetResultReply> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetResultMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 获取实时图片
     * </pre>
     */
    public void getRealtimePic(com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicRequest request,
        io.grpc.stub.StreamObserver<com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicReply> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetRealtimePicMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 算法控制
     * </pre>
     */
    public void algControl(com.yscz.bs.lib.InquestControlOuterClass.ControlParam request,
        io.grpc.stub.StreamObserver<com.yscz.bs.lib.InquestControlOuterClass.ControlResult> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getAlgControlMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   */
  public static final class InquestControlBlockingStub extends io.grpc.stub.AbstractStub<InquestControlBlockingStub> {
    private InquestControlBlockingStub(io.grpc.Channel channel) {
      super(channel);
    }

    private InquestControlBlockingStub(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected InquestControlBlockingStub build(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      return new InquestControlBlockingStub(channel, callOptions);
    }

    /**
     * <pre>
     * 审讯控制
     * </pre>
     */
    public com.yscz.bs.lib.InquestControlOuterClass.StartReply startInquest(com.yscz.bs.lib.InquestControlOuterClass.StartRequest request) {
      return blockingUnaryCall(
          getChannel(), getStartInquestMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 结束面审
     * </pre>
     */
    public com.yscz.bs.lib.InquestControlOuterClass.TerminateReply terminateInquest(com.yscz.bs.lib.InquestControlOuterClass.TerminateRequest request) {
      return blockingUnaryCall(
          getChannel(), getTerminateInquestMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 获取算法结果
     * </pre>
     */
    public com.yscz.bs.lib.InquestControlOuterClass.GetResultReply getResult(com.yscz.bs.lib.InquestControlOuterClass.GetResultRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetResultMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 获取实时图片
     * </pre>
     */
    public com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicReply getRealtimePic(com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetRealtimePicMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 算法控制
     * </pre>
     */
    public com.yscz.bs.lib.InquestControlOuterClass.ControlResult algControl(com.yscz.bs.lib.InquestControlOuterClass.ControlParam request) {
      return blockingUnaryCall(
          getChannel(), getAlgControlMethod(), getCallOptions(), request);
    }
  }

  /**
   */
  public static final class InquestControlFutureStub extends io.grpc.stub.AbstractStub<InquestControlFutureStub> {
    private InquestControlFutureStub(io.grpc.Channel channel) {
      super(channel);
    }

    private InquestControlFutureStub(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected InquestControlFutureStub build(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      return new InquestControlFutureStub(channel, callOptions);
    }

    /**
     * <pre>
     * 审讯控制
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.yscz.bs.lib.InquestControlOuterClass.StartReply> startInquest(
        com.yscz.bs.lib.InquestControlOuterClass.StartRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getStartInquestMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 结束面审
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.yscz.bs.lib.InquestControlOuterClass.TerminateReply> terminateInquest(
        com.yscz.bs.lib.InquestControlOuterClass.TerminateRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getTerminateInquestMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 获取算法结果
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.yscz.bs.lib.InquestControlOuterClass.GetResultReply> getResult(
        com.yscz.bs.lib.InquestControlOuterClass.GetResultRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetResultMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 获取实时图片
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicReply> getRealtimePic(
        com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetRealtimePicMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 算法控制
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<com.yscz.bs.lib.InquestControlOuterClass.ControlResult> algControl(
        com.yscz.bs.lib.InquestControlOuterClass.ControlParam request) {
      return futureUnaryCall(
          getChannel().newCall(getAlgControlMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_START_INQUEST = 0;
  private static final int METHODID_TERMINATE_INQUEST = 1;
  private static final int METHODID_GET_RESULT = 2;
  private static final int METHODID_GET_REALTIME_PIC = 3;
  private static final int METHODID_ALG_CONTROL = 4;

  private static final class MethodHandlers<Req, Resp> implements
      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
    private final InquestControlImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(InquestControlImplBase serviceImpl, int methodId) {
      this.serviceImpl = serviceImpl;
      this.methodId = methodId;
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_START_INQUEST:
          serviceImpl.startInquest((com.yscz.bs.lib.InquestControlOuterClass.StartRequest) request,
              (io.grpc.stub.StreamObserver<com.yscz.bs.lib.InquestControlOuterClass.StartReply>) responseObserver);
          break;
        case METHODID_TERMINATE_INQUEST:
          serviceImpl.terminateInquest((com.yscz.bs.lib.InquestControlOuterClass.TerminateRequest) request,
              (io.grpc.stub.StreamObserver<com.yscz.bs.lib.InquestControlOuterClass.TerminateReply>) responseObserver);
          break;
        case METHODID_GET_RESULT:
          serviceImpl.getResult((com.yscz.bs.lib.InquestControlOuterClass.GetResultRequest) request,
              (io.grpc.stub.StreamObserver<com.yscz.bs.lib.InquestControlOuterClass.GetResultReply>) responseObserver);
          break;
        case METHODID_GET_REALTIME_PIC:
          serviceImpl.getRealtimePic((com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicRequest) request,
              (io.grpc.stub.StreamObserver<com.yscz.bs.lib.InquestControlOuterClass.GetRealtimePicReply>) responseObserver);
          break;
        case METHODID_ALG_CONTROL:
          serviceImpl.algControl((com.yscz.bs.lib.InquestControlOuterClass.ControlParam) request,
              (io.grpc.stub.StreamObserver<com.yscz.bs.lib.InquestControlOuterClass.ControlResult>) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public io.grpc.stub.StreamObserver<Req> invoke(
        io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        default:
          throw new AssertionError();
      }
    }
  }

  private static abstract class InquestControlBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    InquestControlBaseDescriptorSupplier() {}

    @java.lang.Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return com.yscz.bs.lib.InquestControlOuterClass.getDescriptor();
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
      return getFileDescriptor().findServiceByName("InquestControl");
    }
  }

  private static final class InquestControlFileDescriptorSupplier
      extends InquestControlBaseDescriptorSupplier {
    InquestControlFileDescriptorSupplier() {}
  }

  private static final class InquestControlMethodDescriptorSupplier
      extends InquestControlBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    InquestControlMethodDescriptorSupplier(String methodName) {
      this.methodName = methodName;
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
      return getServiceDescriptor().findMethodByName(methodName);
    }
  }

  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (InquestControlGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new InquestControlFileDescriptorSupplier())
              .addMethod(getStartInquestMethod())
              .addMethod(getTerminateInquestMethod())
              .addMethod(getGetResultMethod())
              .addMethod(getGetRealtimePicMethod())
              .addMethod(getAlgControlMethod())
              .build();
        }
      }
    }
    return result;
  }
}
